package com.vehicle.contract.controller;

import java.util.List;
import java.io.IOException;
import java.util.Optional;
import javax.servlet.http.HttpServletResponse;

import com.itextpdf.text.DocumentException;
import com.vehicle.contract.domain.Contract;

import com.vehicle.contract.service.ITIdCardsService;
import com.vehicle.contract.service.OssService;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import com.vehicle.common.log.annotation.Log;
import com.vehicle.common.log.enums.BusinessType;
import com.vehicle.common.security.annotation.PreAuthorize;
import com.vehicle.contract.domain.Car;
import com.vehicle.contract.service.ICarService;
import com.vehicle.common.core.web.controller.BaseController;
import com.vehicle.common.core.web.domain.AjaxResult;
import com.vehicle.common.core.utils.poi.ExcelUtil;
import com.vehicle.common.core.web.page.TableDataInfo;
import org.springframework.web.multipart.MultipartFile;


/**
 * 选择车辆Controller
 *
 * @author Mr.阚
 * @date 2025-03-28
 */
@RestController
@RequestMapping("/car")
public class CarController extends BaseController
{
    @Autowired
    private ICarService carService;
    @Autowired
    private OssService ossService;

    @Autowired
    private ITIdCardsService tIdCardsService;

    /**
     * 查询选择车辆列表
     */
    @PreAuthorize(hasPermi = "contract:car:list")
    @GetMapping("/list")
    public TableDataInfo list(Car car)
    {
        startPage();
        List<Car> list = carService.selectCarList(car);
        return getDataTable(list);
    }

    /**
     * 导出选择车辆列表
     */
    @PreAuthorize(hasPermi = "contract:car:export")
    @Log(title = "选择车辆", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, Car car) throws IOException
    {
        List<Car> list = carService.selectCarList(car);
        ExcelUtil<Car> util = new ExcelUtil<Car>(Car.class);
        util.exportExcel(response, list, "选择车辆数据");
    }

    /**
     * 获取选择车辆详细信息
     */
    @PreAuthorize(hasPermi = "contract:car:query")
    @GetMapping(value = "/{id}")
    public AjaxResult getInfo(@PathVariable("id") Long id)
    {
        return AjaxResult.success(carService.selectCarById(id));
    }

    /**
     * 新增选择车辆
     */
    @PreAuthorize(hasPermi = "contract:car:add")
    @Log(title = "选择车辆", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody Car car)
    {
        return toAjax(carService.insertCar(car));
    }

    /**
     * 修改选择车辆
     */
    @PreAuthorize(hasPermi = "contract:car:edit")
    @Log(title = "选择车辆", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody Car car)
    {
        return toAjax(carService.updateCar(car));
    }

    /**
     * 删除选择车辆
     */
    @PreAuthorize(hasPermi = "contract:car:remove")
    @Log(title = "选择车辆", businessType = BusinessType.DELETE)
	@DeleteMapping("/{ids}")
    public AjaxResult remove(@PathVariable Long[] ids)
    {
        return toAjax(carService.deleteCarByIds(ids));
    }
    /**
     * 创建合同的 HTTP POST 请求处理方法
     * @param contract 合同实体对象，从请求体中获取
     * @return 包含创建成功后的合同实体对象的响应实体，状态码为 201 Created
     */
    @PostMapping("/createContract")
    public AjaxResult createContract(@RequestBody Contract contract) {
        // 调用业务逻辑层创建合同
        return  toAjax(carService.createContract(contract));
    }
    /**
     * 生成合同 PDF 文件的 HTTP GET 请求处理方法
     * @param id 合同的唯一标识，从请求路径中获取
     * @return 包含生成结果信息的响应实体，如果生成成功，状态码为 200 OK；如果合同不存在，状态码为 404 Not Found；如果生成过程中出现异常，状态码为 500 Internal Server Error
     */
    @GetMapping("/generateContractPdf/{id}")
    public AjaxResult generateContractPdf(@PathVariable Long id) {
        // 调用业务逻辑层生成合同 PDF 文件
       Optional<Contract> optionalContract= carService.getContractById(id);
       if (optionalContract.isPresent()){
           //如果合同存在,获取合同实体对象
           Contract contract = optionalContract.get();
           //生成PDF文件的保存路径
           String filePath = "contract_" + contract.getId() + ".pdf";

               // 调用合同服务类的生成合同 PDF 文件的方法
               carService.generateContractPdf(contract,filePath);
               // 返回包含生成成功信息和文件路径的响应实体，
               return AjaxResult.success("PDF 生成成功，路径: " + filePath);


       }
        // 如果合同不存在，返回包含提示信息的响应实体，状态码为 404 Not Found
        return AjaxResult.error("合同不存在");
    }
    /**
     * 签订合同的 HTTP PUT 请求处理方法
     * @param id 合同的唯一标识，从请求路径中获取
     * @return 包含签订成功后的合同实体对象的响应实体，状态码为 200 OK；如果合同不存在，状态码为 404 Not Found
     */
    @PutMapping("/signContract/{id}")
    public AjaxResult signContract(@PathVariable Long id) {

//        调用合同服务类的签订合同方法
      Contract signedContract = carService.signContract(id);
        if (signedContract != null) {
            // 如果签订成功，返回包含签订后合同信息的响应实体，状态码为 200 OK
            return AjaxResult.success(signedContract);
        }
        // 如果合同不存在，返回状态码为 404 Not Found 的响应实体
        return AjaxResult.error("合同不存在");
    }

    /**
     * 人脸识别
     * @param file
     * @return
     */
    @PostMapping("/humanFace")
    public String humanFace(@RequestParam("file") MultipartFile file){

        String uploadFile = ossService.uploadFile(file);
        String humanFace = tIdCardsService.humanFace(uploadFile);

        return humanFace;
    }

}
//   // 调用合同服务类的签订合同方法
//        Contract signedContract = contractService.signContract(id);
//        if (signedContract != null) {
//            // 如果签订成功，返回包含签订后合同信息的响应实体，状态码为 200 OK
//            return new ResponseEntity<>(signedContract, HttpStatus.OK);
//        }
//        // 如果合同不存在，返回状态码为 404 Not Found 的响应实体
//        return new ResponseEntity<>(HttpStatus.NOT_FOUND);

